# -*- coding: utf-8 -*-
"""
金桔王 Langgraph 工作流相关工具函数
"""
import traceback
from datetime import datetime, timedelta
from typing import List, Optional, Dict, Any
from typing import Optional, List, TypedDict
from sqlalchemy.orm import Session
from models import Users, Chat
from common.log import logger
from config import base_config
from pydantic_models import WXWorkIn


class WorkflowState(TypedDict):
    """工作流状态类，用于在节点间传递数据"""
    wx_msg: Optional[WXWorkIn]
    user: Optional[Users]
    chat_history: List[Chat]
    intention: Optional[str]
    permission_granted: bool
    error_message: Optional[str]
    is_group_chat: bool
    final_response: Optional[str]  # 添加final_response字段
    chat_handler: Optional[Any]  # 添加chat_handler字段用于记录workflow处理流程


def get_user_by_userid(userid: str, db: Session) -> Optional[Users]:
    """
    根据企业微信用户ID获取用户信息
    如果用户不存在，返回匿名用户(id=1)
    
    Args:
        userid: 企业微信用户ID
        db: 数据库会话（通过依赖注入获得）
    
    Returns:
        用户对象或匿名用户
    """
    try:
        # 首先尝试通过nickname匹配用户
        user = db.query(Users).filter(
            Users.nickname == userid,
            Users.is_deleted == False
        ).first()
        
        if user:
            logger.info(f"[用户识别] 👤 找到用户: {user.nickname} (ID: {user.id}, 角色: {user.role})")
            return user
        
        # 如果没找到，返回匿名用户
        anonymous_user = db.query(Users).filter(Users.id == 1).first()
        logger.warning(f"[用户识别] ❓ 用户 {userid} 未注册，使用匿名用户")
        return anonymous_user
        
    except Exception as e:
        logger.error(f"[用户识别] ❌ 获取用户信息失败: {e} - {traceback.format_exc()}")
        # 出错时也返回匿名用户
        try:
            anonymous_user = db.query(Users).filter(Users.id == 1).first()
            return anonymous_user
        except:
            return None


def get_chat_history(user_id: int, is_group: bool, db: Session, limit: int = None) -> List[Chat]:
    """
    获取用户的聊天历史记录
    
    Args:
        user_id: 用户ID
        is_group: 是否为群聊
        db: 数据库会话（通过依赖注入获得）
        limit: 限制返回的记录数量，默认使用配置中的 MAX_HISTORY_MSG
    
    Returns:
        聊天历史记录列表，按时间倒序
    """
    if limit is None:
        limit = base_config.MAX_HISTORY_MSG
    
    try:
        # 计算6小时前的时间点
        six_hours_ago = datetime.now() - timedelta(hours=6)
        
        # 根据是否群聊和用户ID查询历史记录，并添加时间限制
        query = db.query(Chat).filter(
            Chat.user_id == user_id,
            Chat.query_time >= six_hours_ago  # 只获取6小时内的消息
        )
        
        # 这里可以根据需要添加群聊/私聊的区分逻辑
        # 目前先简单按用户ID查询
        
        chat_history = query.order_by(Chat.query_time.desc()).limit(limit).all()
        
        logger.info(f"[历史消息] 📚 获取到 {len(chat_history)} 条历史记录 (用户ID: {user_id}, 群聊: {is_group}, 时间范围: 6小时内)")
        
        # 返回时间正序的记录（最老的在前面）
        return list(reversed(chat_history))
        
    except Exception as e:
        logger.error(f"[历史消息] ❌ 获取历史记录失败: {e} - {traceback.format_exc()}")
        return []


def format_chat_history_for_ai(chat_history: List[Chat]) -> str:
    """
    将聊天历史格式化为AI可理解的文本
    
    Args:
        chat_history: 聊天历史记录列表
    
    Returns:
        格式化后的历史记录文本
    """
    if not chat_history:
        return "无历史记录"
    
    formatted_history = []
    for chat in chat_history:
        formatted_history.append(f"用户: {chat.query}")
        formatted_history.append(f"机器人: {chat.ai_answer}")
    
    return "\n".join(formatted_history)


def is_group_chat(wx_msg: WXWorkIn) -> bool:
    """
    判断是否为群聊消息
    
    Args:
        wx_msg: 企业微信消息
    
    Returns:
        True if 群聊, False if 私聊
    """
    return wx_msg.chattype == 'group'


def extract_message_content(wx_msg: WXWorkIn) -> str:
    """
    提取消息内容
    
    Args:
        wx_msg: 企业微信消息
    
    Returns:
        消息文本内容
    """
    if wx_msg.msgtype == 'text' and wx_msg.text:
        return wx_msg.text.content
    return ""


def create_workflow_state_with_db(wx_msg: WXWorkIn, db: Session, chat_handler=None) -> WorkflowState:
    """
    使用数据库会话创建工作流状态对象
    
    Args:
        wx_msg: 企业微信消息
        db: 数据库会话（通过依赖注入获得）
        chat_handler: ChatHandler实例，用于记录workflow处理流程
    
    Returns:
        初始化的工作流状态
    """
    is_group = is_group_chat(wx_msg)
    
    # 获取用户信息和历史记录
    user = get_user_by_userid(wx_msg.from_.userid, db)
    chat_history = []
    if user:
        chat_history = get_chat_history(
            user.id, 
            is_group, 
            db=db
        )
    
    # 返回TypedDict格式的状态
    return WorkflowState(
        wx_msg=wx_msg,
        user=user,
        chat_history=chat_history,
        intention=None,
        permission_granted=False,
        error_message=None,
        is_group_chat=is_group,
        final_response=None,  # 初始化final_response字段
        chat_handler=chat_handler  # 添加chat_handler到状态中
    )


def create_workflow_state(wx_msg: WXWorkIn, chat_handler=None) -> WorkflowState:
    """
    创建工作流状态对象（保持向后兼容）
    
    注意：此函数已弃用，建议使用 create_workflow_state_with_db
    
    Args:
        wx_msg: 企业微信消息
        chat_handler: ChatHandler实例，用于记录workflow处理流程
    
    Returns:
        初始化的工作流状态
    """
    logger.warning("[工作流状态] ⚠️ 使用了已弃用的create_workflow_state函数，建议使用create_workflow_state_with_db")
    
    # 为了向后兼容，仍然创建临时的数据库会话
    from models import SessionLocal
    is_group = is_group_chat(wx_msg)
    
    # 获取用户信息和历史记录
    db = SessionLocal()
    try:
        user = get_user_by_userid(wx_msg.from_.userid, db)
        chat_history = []
        if user:
            chat_history = get_chat_history(
                user.id, 
                is_group, 
                db=db
            )
    finally:
        db.close()
    
    # 返回TypedDict格式的状态
    return WorkflowState(
        wx_msg=wx_msg,
        user=user,
        chat_history=chat_history,
        intention=None,
        permission_granted=False,
        error_message=None,
        is_group_chat=is_group,
        final_response=None,  # 初始化final_response字段
        chat_handler=chat_handler  # 添加chat_handler到状态中
    )